//package com.kz.bot.task;
//
//import com.kz.bot.config.TradeConfig;
//import com.kz.bot.constant.OrderState;
//import com.kz.bot.constant.Side;
//import com.kz.bot.model.Order;
//import com.kz.bot.model.OrderBook;
//import com.kz.bot.model.TradeRecord;
//import com.kz.bot.service.ApiService;
//import com.kz.bot.util.MathCalculationUtil;
//import lombok.RequiredArgsConstructor;
//import lombok.extern.slf4j.Slf4j;
//import org.apache.commons.lang3.StringUtils;
//import org.springframework.boot.context.event.ApplicationReadyEvent;
//import org.springframework.context.event.EventListener;
//import org.springframework.stereotype.Component;
//
//import java.math.BigDecimal;
//import java.math.RoundingMode;
//import java.util.List;
//
//
///**
// * 启动卖出 0.5 然后立马挂买入 全部资金/(当前价格下跌step) - 0.5, 减去0.5的目的是永远留够第一次卖出的资金 假装卖了一次 减少手续费
// * 同时挂 当前价格上涨step * 0.5 * 1*1.2 的卖单
// * 当卖出单成交后 计算加权平均卖价(假设的0.5卖出+本次0.6个币的卖出) 以此为基准,重新挂买单,但是买入数量应该按照 当前总余额-下次预期买入价格卖出0.5个币后的金额,这样可以永远留够第一次交易的0.5个币金额
// * 以避免每一轮结束的买和下一轮开始的卖 所浪费的手续费
// */
//@Slf4j
//@Component
//@RequiredArgsConstructor
//public class BotTask {
//
//    private final TradeConfig config;
//    private final ApiService apiService;
//
//    // 当前卖出轮次，从0开始
//    private int sellCount = 0;
//    // 标志是否完成了初始买入
//    private boolean initialBuyCompleted = false;
//
//    @EventListener(ApplicationReadyEvent.class)
//    public void onReady() {
//        if (StringUtils.isBlank(config.getApiKey())
//                || StringUtils.isBlank(config.getApiSecret())
//                || StringUtils.isBlank(config.getApiPass())) {
//            throw new RuntimeException("ak sk pass 未配置,终止运行");
//        }
//
//        OrderBook book = new OrderBook();
//        BigDecimal step = config.getStepLength();
//        String instId = config.getInstId();
//        int priceScale = config.getPriceScale();
//        int volumeScale = config.getVolumeScale();
//        BigDecimal tradeVolume = config.getTradeVolume();
//
//        // 获取马丁格尔参数
//        BigDecimal volumeMartin = config.getVolumeMartin();
//        BigDecimal priceMartin = config.getPriceMartin();
//
//        BigDecimal lastPrice = apiService.queryLastPrice(instId);
//
//        // ==========================================
//        // 初始化逻辑：检查是否有未完成订单
//        // ==========================================
//        List<Order> currentSellOrders = apiService.currentOrder(instId, Side.sell);
//        List<Order> currentBuyOrders = apiService.currentOrder(instId, Side.buy);
//
//        if (currentSellOrders.isEmpty() && currentBuyOrders.isEmpty()) {
//            // 没有未完成的订单，进入首次交易逻辑
//            log.info("当前没有未完成订单，启动首次交易逻辑");
//
//            // 获取账户余额
//            BigDecimal totalBalanceCoin = apiService.queryAccountBalance(instId.replace("-USDT", ""));
//            if (totalBalanceCoin.compareTo(tradeVolume) < 0) {
//                log.error("当前币种初始持仓量小于单次成交量,{},当前可用余额:{},单次成交量:{}", instId, totalBalanceCoin, tradeVolume);
//                throw new RuntimeException("初始持仓量不足");
//            }
//
//            // 挂初始卖单，数量为 tradeVolume
//            BigDecimal firstSellPrice;
//            if (config.isInitialSellAtCurrentPrice()) {
//                firstSellPrice = lastPrice.setScale(priceScale, RoundingMode.HALF_UP);
//                log.info("以当前最新价格挂出初始卖单");
//            } else {
//                firstSellPrice = lastPrice.multiply(BigDecimal.ONE.add(step)).setScale(priceScale, RoundingMode.HALF_UP);
//                log.info("以当前价格上浮一个step挂出初始卖单");
//            }
//
//            book.currentSellOrder = apiService.placeOrder(instId, Side.sell, tradeVolume, firstSellPrice);
//            if (book.currentSellOrder == null) {
//                throw new RuntimeException("启动挂单失败");
//            }
//            log.info("已挂初始卖单：价格 {}, 数量 {}", firstSellPrice, tradeVolume);
//
//        } else {
//            // 检测到未完成订单，将继续执行上一次的交易逻辑
//            log.info("检测到未完成订单，将继续执行上一次的交易逻辑。");
//            if (currentSellOrders.size() > 1 || currentBuyOrders.size() > 1) {
//                throw new RuntimeException("该账户下该币种当前存在的卖单或买单超过1个");
//            }
//            if (!currentSellOrders.isEmpty()) {
//                book.currentSellOrder = currentSellOrders.getFirst();
//            }
//            if (!currentBuyOrders.isEmpty()) {
//                book.currentBuyOrder = currentBuyOrders.getFirst();
//            }
//        }
//
//        while (true) {
//            try {
//                // ==========================================================
//                // 核心逻辑1: 检查买单状态，如果成交，则重置策略周期
//                // ==========================================================
//                if (book.currentBuyOrder != null && OrderState.filled.name().equals(apiService.queryOrderStatus(instId, book.currentBuyOrder.getOrdId()))) {
//                    log.info("买单成交，本轮周期结束，重置策略");
//
//                    // 在重置前获取买单成交价
//                    BigDecimal buyOrderPrice = book.currentBuyOrder.getPrice();
//
//                    apiService.cancelOrder(instId, book.currentSellOrder.getOrdId());
//                    resetState(book);
//
//                    // 以买单成交价作为新周期的基准，挂出新的卖单
//                    BigDecimal nextSellPrice = buyOrderPrice.multiply(BigDecimal.ONE.add(step)).setScale(priceScale, RoundingMode.HALF_UP);
//                    book.currentSellOrder = apiService.placeOrder(instId, Side.sell, tradeVolume, nextSellPrice);
//                    log.info("已重置并挂出新的卖单：价格 {}, 数量 {}", nextSellPrice, tradeVolume);
//                }
//
//                // ==========================================================
//                // 核心逻辑2: 检查卖单状态，如果成交，则挂新卖单和买单
//                // ==========================================================
//                if (book.currentSellOrder != null && OrderState.filled.name().equals(apiService.queryOrderStatus(instId, book.currentSellOrder.getOrdId()))) {
//                    log.info("卖单成交，开始计算下一轮卖单和买入价格");
//
//                    // 卖单完全成交，保存成交记录
//                    TradeRecord sell = new TradeRecord();
//                    sell.price = book.currentSellOrder.getPrice();
//                    sell.volume = book.currentSellOrder.getVolume();
//                    book.sellHistory.add(sell);
//                    sellCount++;
//
//                    // 撤销旧买单
//                    if (book.currentBuyOrder != null) {
//                        apiService.cancelOrder(instId, book.currentBuyOrder.getOrdId());
//                        book.currentBuyOrder = null;
//                    }
//
//                    // 计算卖单加权均价
//                    BigDecimal totalSellVolume = BigDecimal.ZERO;
//                    BigDecimal weightedSum = BigDecimal.ZERO;
//                    for (TradeRecord t : book.sellHistory) {
//                        weightedSum = weightedSum.add(t.getPrice().multiply(t.getVolume()));
//                        totalSellVolume = totalSellVolume.add(t.getVolume());
//                    }
//                    BigDecimal avgSellPrice = weightedSum.divide(totalSellVolume, priceScale, RoundingMode.HALF_UP);
//                    log.info("累计卖出轮次: {}, 平均卖出价: {}", sellCount, avgSellPrice);
//
//                    // ==============================
//                    // 挂新的买单
//                    // ==============================
//                    BigDecimal nextBuyPrice = avgSellPrice.multiply(BigDecimal.ONE.subtract(step)).setScale(priceScale, RoundingMode.HALF_UP);
//                    BigDecimal buyVolume = totalSellVolume.setScale(volumeScale, RoundingMode.DOWN);
//
//                    if (buyVolume.compareTo(BigDecimal.ZERO) > 0) {
//                        book.currentBuyOrder = apiService.placeOrder(instId, Side.buy, buyVolume, nextBuyPrice);
//                        log.info("已挂真实买单：价格 {}, 数量 {}", nextBuyPrice, buyVolume);
//                    } else {
//                        log.info("买入量为0或负数，无需挂买单。buyVolume: {}", buyVolume);
//                        book.currentBuyOrder = null;
//                    }
//
//                    // ==============================
//                    // 挂下一次卖单（等待下一轮上涨）
//                    // ==============================
//                    BigDecimal nextSellPrice = avgSellPrice.multiply(BigDecimal.ONE.add(step.multiply(MathCalculationUtil.pow(priceMartin, BigDecimal.valueOf(sellCount), 10))))
//                            .setScale(priceScale, RoundingMode.HALF_UP);
//                    BigDecimal martinVolume = tradeVolume.multiply(MathCalculationUtil.pow(volumeMartin, BigDecimal.valueOf(sellCount), 10)).setScale(volumeScale, RoundingMode.DOWN);
//
//                    book.currentSellOrder = apiService.placeOrder(instId, Side.sell, martinVolume, nextSellPrice);
//                }
//
//                Thread.sleep(2000); // 每2秒检查一次订单状态
//            } catch (Exception e) {
//                log.error("循环中异常", e);
//            }
//        }
//    }
//
//    private void resetState(OrderBook book) {
//        sellCount = 0;
//        book.sellHistory.clear();
//        book.currentBuyOrder = null;
//    }
//}